public class Main {
    public static void main(String[] args) {
        /**
         * 数组的创建与使用*/
        // 动态创建数组（看自己的喜好和具体的需求进行创建，但是我不确定专升本是否会考这种知识点）
        int[] arr = new int[]{7, 6, 1, 3, 9, 2, 5, 0, 4, 8};
        int[] arrEmpty = new int[10];
        int[] arrOrdered = new int[]{-1, 1, 2, 11, 23, 24, 29, 31, 36};

        // 1 测试数组转字符串
        // System.out.println(toString(new int[]{}));

        // 2 测试拷贝数组
        // int[] copyArray = copyOf(arrEmpty);
        // copyArray[0] = 9;
        // System.out.println(toString(arrEmpty));
        // System.out.println(toString(copyArray));

        // 3 测试寻找数组最大值
        // int retMax = max(new int[]{});
        // System.out.println(retMax);

        // 4 测试寻找数组元素均值
        // double avg = average(arr);
        // System.out.println(avg);

        // 5 测试查找数组中指定元素
        // int index = find(arr, -10);
        // System.out.println(index);

        // 6 测试二分查找数组中指定元素
        // int index = binarySearch(arrOrdered, 36);
        // System.out.println(index);

        // 7 测试检查数组的有序性
        // System.out.println(checkArray(arr));
        // System.out.println(checkArray(arrOrdered));
        // System.out.println(checkArray(new int[]{}));

        //
    }

    public static boolean checkArray(int[] arr) {
        /**
         * 检查数组的有序性-升序（前一个元素必须小于等于后一个元素）*/
        // 1 判空（空数组认为有序）
        if(arr.length == 0) {
            return true;
        }

        // 2 循环判断
        int prev = arr[0];
        for(int e: arr) {
            if(prev <= e) {
                prev = e;
            } else {
                return false;
            }
        }

        // 3 返回值
        return true;
    }

    public static String toString(int[] arr) {
        /**
         * 数组转字符串（手动实现）*/
        // 1 创建返回值
        StringBuffer ret = new StringBuffer("[");

        // 2 遍历数组
        for(int i = 0; i < arr.length; i++) {
            ret.append(arr[i]);
            if(i != arr.length - 1) {
                ret.append(", ");
            }
        }
        ret.append("]");

        // 3 返回值
        return ret.toString();
    }

    public static int[] copyOf(int[] arr) {
        /**
         * 拷贝数组（手动实现）*/
        // 1 创建返回数组
        int[] ret = new int[arr.length];

        // 2 遍历拷贝
        for(int i = 0; i < arr.length; i++) {
            ret[i] = arr[i];
        }

        // 3 返回值
        return ret;
    }

    public static int max(int[] arr) {
        /**
         * 找到数组中的最大元素*/
        // 1 判空
        if(arr.length == 0) {
            // -应当抛出异常
            return -1;
        }
        int maxValue = arr[0];

        // 2 寻找数组最大值
        for(int e: arr) {
            if(e > maxValue) {
                maxValue = e;
            }
        }

        // 3 返回值
        return maxValue;
    }

    public static double average(int[] arr) {
        /**
         * 求数组中元素的平均值*/
        // 1 判空
        if(arr.length == 0) {
            // -应当抛出异常
            return -1;
        }
        int total = arr[0];

        // 2 求和
        for(int e: arr) {
            total += e;
        }

        // 3 返回值
        return total / (double)arr.length;
    }

    public static int find(int[] arr, int key) {
        /**
         * 查找数组中的指定元素
         * @return:返回指定元素下标*/
        // 1 创建返回值变量
        int retIndex = -1;

        // 2 循环查找
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] == key) {
                retIndex = i;
                break;
            }
        }

        // 3 返回值
        return retIndex;
    }

    public static int binarySearch(int[] arr, int key) {
        /**
         * 二分查找数组中的指定元素（数组具有二段性，常见的二段性即有序）*/
        // 1 创建返回下标
        int retIndex = -1;

        // 2 二分查找
        int left = 0;
        int right = arr.length - 1;
        while(left <= right) { // -left == right时也需要再进去，否则会漏判一个点
            // -1 找中间点（偏左）
            int mid = left + (right - left) / 2;
            if(arr[mid] > key) {
                right = mid - 1;
            } else if(arr[mid] < key) {
                left = mid + 1;
            } else {
                retIndex = mid;
                break;
            }
        }

        // 3 返回值
        return retIndex;
    }
}
